What type of PR is this?

• API-change
• BUG
• Improvement
• Documentation
• Feature
• Test and CI
• Code Refactoring

Which issue(s) this PR fixes:

issue #25699

Part of #25612. Follows #25613, which deferred TIME_WINDOW because its
row-count and special-slot contracts needed an execution-layer design.

What this PR does / why we need it:

The issue describes a missed optimization; it is also a wrong-answer bug

TIME_WINDOW's output batch layout was derived independently in two places:

• remapAllColRefs addressed slots with a counter that only advanced for
  projected entries;
• constructTimeWindow / calRes built the batch from the unpruned
  AggList.

As soon as an outer query discarded any window output, the two drifted and the
projection read a neighbouring column. Reproduced on a live instance
(interval(ts, 5, second) over two windows; baseline _wstart, max(v), min(v)
= (00:00:00, 20, 10), (00:00:05, 40, 30)):

Sliding windows are affected identically (select c returned 40, 40 for
min(v)). Causes, respectively: the compacted counter; the same counter
applied to a boundary slot; a break inside the switch that skipped the
_wend branch along with _wstart; and constructFill sizing ColLen from a
FILL.AggList that was never pruned alongside the window's.

Fix

BuildTimeWindowLayout becomes the single source of truth for the layout
([aggregates…, _wstart?, _wend?, partition keys…]), consumed by both the
planner and the compiler, so the two cannot drift again. Pruning then follows
from it:

• only retained aggregates take a reference on their inputs, so the child AGG
  drops those inputs too — the "prune aggregates and their inputs" the issue
  asks for;
• FILL prunes its columns and FillVal in step with the window. This must be
  decided before FillVal's refcounts, because fill(linear) builds
  FillVal out of references to those very aggregates and would otherwise keep
  every one alive;
• a row carrier is retained when every value is discarded — calRes sizes its
  batch off Vecs[0], and the window count is still the row count. A boundary
  is preferred, since it runs no aggregate;
• every _wstart reference maps to the one boundary slot, so repeats cannot
  drop a projection.

select c from (… max(v), min(v) …) x now compacts AggList from 3 entries to
1, and the child AGG drops max(v) and its input column.

GROUP BY + time window: partitioned execution

select _wstart, other, max(v) from t group by other interval(ts,5,second)
previously panicked. The window was never partitioned at all — the child AGG
grouped by (other, trunc_ts) while the window sorted by trunc_ts alone,
interleaving groups into one global stream, and the operator never emitted the
group column. This PR carries those keys as TimeWindowPartitionBy, orders by
them ahead of the timestamp, and restarts the window state at each boundary so
each group gets its own windows. Partition keys are never pruned (dropping one
would merge groups) and land in the tail slots, keeping the aggregates a prefix
for FILL.

Two further latent bugs found and fixed here

• node.WEnd's column reference was never remapped. The operator evaluates
  it against a batch holding only the timestamp, so it worked only while the
  window key happened to be group column 0; group by id moves it to 1 and it
  reads out of range. resetTimeWindowTsColRef makes the contract explicit.
• Every flush after the first orphaned its aggregate vectors. Only the
  Flush() results are owned by that batch (boundaries belong to their
  expression executors, partition keys to ctr.partOut). Previously this needed
  more than 8192 windows; partitioning makes flushing routine.

Also removes fill.AggIds, which was assigned by constructFill and never read.

Review round: partition-aware FILL and further fixes

All seven review findings were verified and fixed:

• fill(prev/next/linear) leaked values across partitions — prev filled a
  group's leading NULL with the previous group's value; next dropped whole
  batches. The partition key positions now travel to the FILL operator
  (time_window_partition_col_pos), and all three modes treat a key change as
  a hard boundary. NEXT/LINEAR are rewritten to materialize their input first:
  the old per-column streaming state machine returned early whenever a batch
  contained no NULL and silently discarded every batch after it (a
  pre-existing bug that partitioning made routine).
• A window spanning two batches was dropped — fillRows reset
  withoutFill per batch instead of per window, so a window whose rows came
  in one batch and whose closing row came in the next was emitted as empty.
  Found by the new batch-split invariance test.
• remakeAggs leaked one set of aggregate executors per partition — the old
  executor still owns its state after Flush; it is now freed first.
• Side-effecting fill values were pruned — fill(value, sleep(1)) on a
  discarded column now pins the matching window slot (verified end-to-end:
  1.02s with sleep retained vs 0.017s with a plain value pruned).
• TimeWindowPartitionBy joins the planner infrastructure —
  DeepCopyNode (whose TIME_WINDOW/FILL fields were never copied at all),
  the plan visitor, and replaceColumnsForNode, each with tests.
• make static-check passes — the two prealloc findings are fixed.
• The golden file's pre-existing expectations are restored — genrs had
  rewritten them into the new recorder format; only this PR's cases are
  appended now (verified: zero deleted lines, suite 61/61).

Partitioned fill(prev/next/linear) was re-verified against per-partition
references over 9200 rows / 4 partitions: identical (576/576/576/863 rows
across the four specs).

Tests

• Differential (the strongest signal): 9200 rows / 4 partitions / irregular
  gaps, comparing group by p <spec> against per-partition where p=N <spec>.
  Identical across interval(1 minute) (1723 rows), interval(3 minute) fill(prev) (576), sliding(2 minute) (863), sliding(20 minute) (88), and
  interval(30s) sliding(10s) (8794 rows, spanning batch boundaries). This
  caught two bugs in the implementation: partitions losing their trailing
  windows, and an out-of-range read that broke all non-sliding time-window
  queries.
• UT: BuildTimeWindowLayout (slot/boundary/partition/repeat/empty cases and
  a planner-vs-compiler consistency check); plan-shape tests for each pruning
  shape above; operator tests for partition reset, trailing windows,
  single-partition equivalence with the unpartitioned operator, NULL keys
  grouping together, and the pass-through path — all asserting CurrNB() == 0,
  which is what surfaced the flush leak.
• BVT: new cases in optimizer/column_pruning covering every query in the
  table above plus sliding, all three fill modes, empty input, row carriers,
  and partitioned windows.

Coverage of changed code: time_window_layout.go 100%; the TIME_WINDOW/FILL
remap branches 92.3%; colexec/timewin 35.4% → 72.9%.

Suites: time_window 31/31, optimizer 1078/1078, window 1543/1559 — the 4
failures are external01 external-table reads returning 0 rows, verified to
fail identically on an unmodified baseline build (select count(*) from external01 has no TIME_WINDOW node at all).

Review round 2: TimeWin reusable after Reset (195c1a0)

Reproduced the reported crash: a partitioned sliding TimeWin run to ExecStop,
then Reset + Prepare with a fresh child, panicked in
nextWindow -> AggFuncExec.GroupGrow on the second run.

• resetParam now rewinds every per-generation field: the buffer cursor
  i (so tsVec/aggVec/partVec reuse restarts at index 0 instead of
  appending after stale entries), the window cursors and bounds
  (curVecIdx/curRowIdx, preVecIdx/preRowIdx, left/right,
  nextLeft/nextRight), last/lastVal, withoutFill, and all partition
  break state (partEnd, breakVecIdx/breakRowIdx, partLast*). With the
  cursors at zero, receive routes into firstWindow again.
• Reset now establishes the generation boundary for owned memory: it frees
  the aggregate prefix of the last flushed batch (the only part that batch
  owns — boundaries belong to their expression executors, partition keys to
  partOut), drops the batch reference, and discards the flushed aggregate
  executors (they cannot be rewound after Flush, the same property
  remakeAggs documents). Prepare rebuilds the aggregates behind a gate
  separate from the expression executors.
• freeVector additionally releases the _wstart/_wend staging vectors,
  which the Reset path would otherwise retain.
• Regression tests (TestTimeWinReuseAfterReset,
  TestTimeWinIntervalPathReuseAfterReset): exhaust the operator,
  Reset + Prepare, exhaust it again on fresh input, compare the two
  complete outputs, and assert CurrNB() == 0 after Free — for the
  partitioned sliding, plain sliding, and interval pass-through paths. The
  first generation reads two child batches and the second reads one, so the
  index-0 buffer-reuse claim is exercised, not just asserted. Reverting the
  fix makes the new test fail with the exact reported stack (panic in
  nextWindow).

Verification: colexec/timewin UT green incl. -race, coverage 77.5%
(Reset/resetParam 100%); BVT time_window 31/31 and
optimizer/column_pruning 61/61; prepared-statement re-execution of a
partitioned sliding window returns identical results across executions.

Review round 3: fill(next/linear) incremental again, not fully materialized (957441a)

The round-2 rewrite gathered the entire child stream before emitting the first
NEXT/LINEAR result, which turned even the no-NULL path into O(total rows)
retained memory and full-input first-row latency (an outer LIMIT 1 could not
stop the child; a wide time range could OOM although no look-ahead was needed).

Replaced with a batch-level incremental engine:

• bats is now a pending FIFO keyed by an absolute sequence number (baseSeq),
  so a captured coordinate stays valid after the FIFO pops its head. A batch is
  emitted as soon as every fill column has resolved its rows; the child is
  pulled again only when nothing is emittable. toFree releases the batch handed
  to the parent on the previous Call.
• NEXT keeps each column's unfilled NULL run and back-fills it on the next
  non-NULL value; LINEAR keeps the last non-NULL as a left endpoint and pins its
  batch until superseded, interpolating a pending run against it. Partition
  boundaries drop the pending candidates (they stay NULL), preserving the
  existing cross-partition semantics. A no-NULL NEXT stream buffers nothing; a
  no-NULL LINEAR stream buffers at most one batch. A genuinely long unresolved
  suffix still buffers until the next value, which is inherent to the operator's
  semantics (the original streamed the same way); no disk spill.
• Deterministic regressions with a call-counting child: NEXT emits its first
  batch after exactly one child pull and LINEAR after one look-ahead, both well
  before child EOF, with len(ctr.bats) <= 1 throughout; plus long cross-batch
  gaps, EOF tails, independent multi-column gaps, and cross-batch LINEAR
  interpolation.

Verification: colexec/fill UT green incl. -race, coverage 85.4%,
golangci-lint 0 issues; BVT time_window 31/31 and optimizer/column_pruning
61/61; partitioned prev/next/linear/value verified end to end with no
cross-partition bleed and LIMIT 1 returning immediately.